home *** CD-ROM | disk | FTP | other *** search
/ Compendium Deluxe 1 / LSD Compendium Deluxe 1.iso / a / text / manipulation / cv.lha / cv / cvt / flist.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-12-31  |  4.9 KB  |  266 lines
  1. /*                                                               -*- C -*-
  2.  *  FLIST.C
  3.  *
  4.  *  (c)Copyright 1992-93 by Tobias Ferber,  All Rights Reserved.
  5.  */
  6.  
  7. #include <ctype.h>
  8. #include <string.h>
  9. #include <stdlib.h>
  10. #include <stdio.h>
  11.  
  12. #include "cvt.h"
  13.  
  14. /*** / GLOBALS / ***/
  15.  
  16. int global_numfiles= 0;
  17. fnode_t *flist= NIL(fnode_t);
  18.  
  19.  
  20. int chain_fname(char *host, char *fname)
  21. {
  22.   static fnode_t *tail= NIL(fnode_t);
  23.   fnode_t *fn;
  24.  
  25.   if( fn= (struct fnode *)malloc(sizeof(struct fnode)) )
  26.   {
  27.     if( fn->filename= (char *)malloc((strlen(fname)+1)*sizeof(char)) )
  28.     {
  29.       strcpy(fn->filename, fname);
  30.       fn->hostname= host;
  31.       fn->next= NIL(fnode_t);
  32.  
  33.       if(!flist)
  34.         flist= fn;
  35.  
  36.       if(tail)
  37.         tail->next= fn;
  38.  
  39.       tail= fn;
  40.       ++global_numfiles;
  41.     }
  42.     else
  43.     {
  44.       free(fn);
  45.       fn= NIL(fnode_t);
  46.     }
  47.   }
  48.   return fn ? 0:1;
  49. }
  50.  
  51.  
  52. void purge_flist(void)
  53. {
  54.   while(flist)
  55.   {
  56.     fnode_t *t= flist;
  57.     flist= flist->next;
  58.  
  59.     if(t->filename)
  60.       free(t->filename);
  61.     free(t);
  62.   }
  63.   global_numfiles= 0;
  64. }
  65.  
  66.  
  67. int get_fname(FILE *fp, char *fname)
  68. {
  69.   int c, n=0;
  70.   static int line= 1;
  71.  
  72.   typedef enum { outer_mode,
  73.                  word_mode,
  74.                  string_mode,
  75.                  return_mode,
  76.                  error_mode
  77.                } smode_t;
  78.  
  79.   smode_t smode= outer_mode;
  80.  
  81.   while( smode != return_mode && smode != error_mode && !feof(fp) )
  82.   {
  83.     c= fgetc(fp);
  84.  
  85.     if(feof(fp) && c!=EOF)
  86.       c= EOF;
  87.  
  88.     switch(c)
  89.     {
  90.       case ' ': case '\t':
  91.         switch(smode)
  92.         {
  93.           case word_mode:
  94.             fname[n++]= '\0';
  95.             smode= return_mode;
  96.             break;
  97.  
  98.           case string_mode:
  99.             fname[n++]= c;
  100.             break;
  101.         }
  102.         break;
  103.  
  104.       case '\n': case '\r':
  105.         switch(smode)
  106.         {
  107.           case word_mode:
  108.             fname[n++]= '\0';
  109.             smode= return_mode;
  110.             break;
  111.  
  112.           case string_mode:
  113.             sprintf(fname,"%d: unterminated string at EOL; missing quotes",line);
  114.             smode= error_mode;
  115.             break;
  116.         }
  117.         line++;
  118.  
  119.         { int d= fgetc(fp);
  120.           if( !(c=='\n' && d=='\r' || c=='\r' && d=='\n') )
  121.             ungetc(d,fp);
  122.         }
  123.         break;
  124.  
  125.       case '\"':
  126.         switch(smode)
  127.         {
  128.           case outer_mode:
  129.             smode= string_mode;
  130.             break;
  131.  
  132.           case string_mode:
  133.             fname[n++]= '\0';
  134.             smode= return_mode;
  135.             break;
  136.  
  137.           case word_mode:
  138.             fname[n++]= '\0';
  139.             ungetc(c,fp);
  140.             smode= return_mode;
  141.             break;
  142.         }
  143.         break;
  144.  
  145.       case EOF:
  146.         switch(smode)
  147.         {
  148.           case word_mode:
  149.             if( feof(fp) )
  150.             {
  151.               fname[n++]= '\0';
  152.               smode= return_mode;
  153.             }
  154.             else fname[n++]= c;
  155.             break;
  156.  
  157.           case string_mode:
  158.             if( feof(fp) )
  159.             {
  160.               sprintf(fname,"%d: unterminated string at EOF",line);
  161.               smode= error_mode;
  162.             }
  163.             else fname[n++]= c;
  164.             break;
  165.         }
  166.         break;
  167.  
  168.       default:
  169.         switch(smode)
  170.         {
  171.           case outer_mode:
  172.             smode= word_mode;
  173.             /* fall through */
  174.  
  175.           case word_mode:
  176.           case string_mode:
  177.             fname[n++]= c;
  178.             break;
  179.         }
  180.         break;
  181.     }
  182.  
  183.     if(n >= MAXIMUM_PATHNAME_LENGTH)
  184.     {
  185.       sprintf(fname,"%d: line too long",line);
  186.       smode= error_mode;
  187.     }
  188.   }
  189.  
  190.   fname[n]= '\0';
  191.   return (smode == error_mode) ? 0 : line;
  192. }
  193.  
  194.  
  195. int read_flist(char *host)
  196. {
  197.   char *fname;
  198.  
  199.   if( fname= (char *)malloc(MAXIMUM_PATHNAME_LENGTH * sizeof(char)) )
  200.   {
  201.     FILE *fp, *tf;
  202.  
  203.     if( fp= fopen(host, "r") )
  204.     {
  205.       int line= 1;
  206.  
  207.       while( line > 0 && !feof(fp) && !ferror(fp) )
  208.       {
  209.         line= get_fname(fp, fname);
  210.  
  211.         if(*fname)
  212.         {
  213.           if(line > 0)
  214.           {
  215.             if( global_checkexists )
  216.             {
  217.               if( tf= fopen(fname,"r") )
  218.                 fclose(tf);
  219.  
  220.               else
  221.               { echo("In file `%s' line %d:",host,line);
  222.                 perror(fname);
  223.                 return 3;
  224.               }
  225.             }
  226.  
  227.             if( chain_fname(host,fname) )
  228.             { echo("%s: ran out of memory in line %d",host,line);
  229.               return 4;
  230.             }
  231.           }
  232.           else
  233.           { echo("%s: %s",host,fname);
  234.             return 2;
  235.           }
  236.         }
  237.         /* else feof(fp) ?! */
  238.       }
  239.       fclose(fp);
  240.     }
  241.     free(fname);
  242.     return 0;
  243.   }
  244.   perror(host);
  245.   return 1;
  246. }
  247.  
  248.  
  249. #ifdef DEBUG
  250. void print_flist(void)
  251. {
  252.   fnode_t *fn= flist;
  253.  
  254.   if(fn)
  255.   {
  256.     int n;
  257.     printf("list of input files:\n");
  258.  
  259.     for(n=0; fn; n++, fn= fn->next)
  260.       printf("\t%s: \"%s\"\n", (fn->hostname ? fn->hostname
  261.                                              : "command-line"), fn->filename);
  262.   }
  263.   else printf("no input files specified.\n");
  264. }
  265. #endif /* DEBUG */
  266.